
package com.jf.cloud.product.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import com.jf.cloud.api.auth.constant.SysTypeEnum;
import com.jf.cloud.api.leaf.feign.SegmentFeignClient;
import com.jf.cloud.api.multishop.feign.ShopSubstituteSalesFeignClient;
import com.jf.cloud.api.multishop.feign.ShopUserFeignClient;
import com.jf.cloud.api.multishop.vo.ShopUserVO;
import com.jf.cloud.api.product.util.ProductLangUtil;
import com.jf.cloud.common.cache.constant.CacheNames;
import com.jf.cloud.common.cache.constant.LockCacheNames;
import com.jf.cloud.common.cache.constant.ProductCacheNames;
import com.jf.cloud.common.cache.util.RedisUtil;
import com.jf.cloud.common.constant.Constant;
import com.jf.cloud.common.constant.DistributedIdKey;
import com.jf.cloud.common.constant.StatusEnum;
import com.jf.cloud.common.database.dto.PageDTO;
import com.jf.cloud.common.database.util.PageUtil;
import com.jf.cloud.common.database.vo.PageVO;
import com.jf.cloud.common.exception.LuckException;
import com.jf.cloud.common.i18n.I18nMessage;
import com.jf.cloud.common.i18n.LanguageEnum;
import com.jf.cloud.common.product.constant.*;
import com.jf.cloud.common.product.dto.*;
import com.jf.cloud.common.product.vo.*;
import com.jf.cloud.common.product.vo.StockBillLogItemVO;
import com.jf.cloud.common.product.vo.StockBillLogVO;
import com.jf.cloud.common.product.vo.app.SkuAppVO;
import com.jf.cloud.common.product.vo.search.SpuAdminVO;
import com.jf.cloud.common.response.ResponseEnum;
import com.jf.cloud.common.response.ServerResponseEntity;
import com.jf.cloud.common.rocketmq.config.RocketMqConstant;
import com.jf.cloud.common.security.AuthUserContext;
import com.jf.cloud.common.util.Arith;
import com.jf.cloud.common.util.BooleanUtil;
import com.jf.cloud.common.util.PriceUtil;
import com.jf.cloud.common.vo.ShopSubstituteSalesVO;
import com.jf.cloud.product.bo.SkuZoneInfoBO;
import com.jf.cloud.product.dto.StockBillLogItemDTO;
import com.jf.cloud.product.mapper.SkuMapper;
import com.jf.cloud.product.mapper.SkuStockMapper;
import com.jf.cloud.product.mapper.SpuMapper;
import com.jf.cloud.product.mapper.SpuPriceLogMapper;
import com.jf.cloud.product.model.*;
import com.jf.cloud.product.service.*;
import com.jf.cloud.product.vo.*;
import ma.glasnost.orika.MapperFacade;
import org.apache.rocketmq.client.producer.SendStatus;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.context.annotation.Lazy;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * sku信息
 *
 * @author zz
 * @date 2020-10-28 15:27:24
 */
@Service
public class SkuServiceImpl implements SkuService {
    private final Logger logger = LoggerFactory.getLogger(SkuServiceImpl.class);

    @Autowired
    private SkuMapper skuMapper;
    @Autowired
    private SpuSkuAttrValueService spuSkuAttrValueService;
    @Autowired
    private SkuStockService skuStockService;
    @Autowired
    private SkuLangService skuLangService;
    @Autowired
    private MapperFacade mapperFacade;
    @Autowired
    private SpuMapper spuMapper;
    @Autowired
    private SpuPriceLogMapper spuPriceLogMapper;
    @Autowired
    @Lazy
    private SpuSupplierChangeLogService spuSupplierChangeLogService;
    @Autowired
    private ShopSubstituteSalesFeignClient shopSubstituteSalesFeignClient;
    @Autowired
    private SkuStockMapper skuStockMapper;
    @Autowired
    private SegmentFeignClient segmentFeignClient;
    @Autowired
    private ShopUserFeignClient shopUserFeignClient;
    @Autowired
    private RocketMQTemplate stockBillLogTemplate;
    @Autowired
    private RedissonClient redissonClient;

    @Override
    public void save(Long spuId, List<SkuDTO> skuList, Integer sysType, Long userId, Long shopId) {
        skuList.forEach(sku -> {
            sku.setSpuId(spuId);
            if(Objects.isNull(sku.getStatus())){
                sku.setStatus(StatusEnum.ENABLE.value());
            }
            if (StrUtil.isBlank(sku.getImgUrl())) {
                sku.setImgUrl(null);
            }
            if (Objects.isNull(sku.getScoreFee())) {
                sku.setScoreFee(Constant.ZERO_LONG);
            }
            if(Objects.isNull(sku.getStockWarning())){
                sku.setStockWarning(0L);
            }
        });
        // 处理数据，保存库存、属性
        skuMapper.saveBatch(skuList);
        List<SkuVO> skuDbList = skuMapper.getBySpuId(spuId);
        List<SkuStock> skuStocks = new ArrayList<>();
        List<SpuSkuAttrValueDTO> spuSkuAttrValues = new ArrayList<>();
        List<SkuLangDTO> skuLangList = new ArrayList<>();
        for (SkuDTO skuDTO : skuList) {
            SkuStock skuStock = new SkuStock();
            skuStock.setSkuId(skuDTO.getSkuId());
            skuStock.setStock(skuDTO.getStock());
            skuStock.setActualStock(skuDTO.getStock());
            skuStock.setLockStock(0);
            skuStock.setSpuId(spuId);
            skuStocks.add(skuStock);
            if (CollUtil.isEmpty(skuDTO.getSpuSkuAttrValues())) {
                continue;
            }
            for (SkuLangDTO skuLangDTO : skuDTO.getSkuLangList()) {
                skuLangDTO.setSkuId(skuDTO.getSkuId());
                skuLangList.add(skuLangDTO);
            }
            for (SpuSkuAttrValueDTO spuSkuAttrValue : skuDTO.getSpuSkuAttrValues()) {
                spuSkuAttrValue.setSpuId(spuId);
                spuSkuAttrValue.setSkuId(skuDTO.getSkuId());
                spuSkuAttrValue.setStatus(StatusEnum.ENABLE.value());
                spuSkuAttrValues.add(spuSkuAttrValue);
            }
        }
        skuLangService.batchSave(mapperFacade.mapAsList(skuLangList, SkuLang.class));
        skuStockService.batchSave(skuStocks);
        spuSkuAttrValueService.save(spuSkuAttrValues, sysType);
        //供应商新增sku时，生成对应的变更记录
        if(skuList.size() > skuDbList.size()){
            SpuSupplierChangeLog spuSupplierChangeLog = new SpuSupplierChangeLog();
            spuSupplierChangeLog.setSpuId(spuId);
            spuSupplierChangeLog.setChangeType(SupplierSpuChangeType.ADD_SKU.value());
            spuSupplierChangeLogService.save(spuSupplierChangeLog);
        }
        if(Objects.equals(sysType, SysTypeEnum.MULTISHOP.value())) {
            for(SkuDTO skuDTO : skuList){
                skuDTO.setChangeStock(skuDTO.getStock());
            }
            List<StockBillLogItemVO> stockBillLogItemVOList = loadStockBillLogItems(spuId, skuList);
            StockBillLogVO stockBillLogVO = loadStockBillLog(StockType.WAREHOUSING.value(), StockBillType.INITIALIZE.value(), stockBillLogItemVOList, userId, shopId);
            //发送事件进行添加商品库存初始化记录
            SendStatus sendStockStatus = stockBillLogTemplate.syncSend(RocketMqConstant.STOCK_BILL_LOG_TOPIC, new GenericMessage<>(stockBillLogVO)).getSendStatus();
            if (!Objects.equals(sendStockStatus, SendStatus.SEND_OK)) {
                throw new LuckException(ResponseEnum.EXCEPTION);
            }
        }

    }


    @Override
    public void update(Long spuId, List<SkuDTO> skuList) {
        // 从获取旧的sku的数据
        List<SkuVO> skuListDb = listSkuWithAttrBySpuId(spuId);
        // skuId
        List<Long> skuIdsDb = skuListDb.stream().map(SkuVO::getSkuId).collect(Collectors.toList());
        List<Long> skuIds = new ArrayList<>();
        List<SkuDTO> updateSkus = new ArrayList<>();
        List<SkuDTO> insertSkus = new ArrayList<>();
        // 原有sku增加库存的sku列表(不包含新增的sku)
        List<SkuDTO> addStockSkuList = new ArrayList<>();
        // 原有sku减少库存的sku列表(不包含新增的sku)
        List<SkuDTO> reduceStockSkuList = new ArrayList<>();
        for (SkuDTO sku : skuList) {
//            if (StrUtil.isBlank(sku.getImgUrl())) {
//                sku.setImgUrl(null);
//            }
            sku.setSpuId(spuId);
            if (skuIdsDb.contains(sku.getSkuId())) {
                if(Objects.nonNull(sku.getChangeStock()) && sku.getChangeStock() > 0){
                    // 库存增加
                    addStockSkuList.add(sku);
                }
                if (Objects.nonNull(sku.getChangeStock()) && sku.getChangeStock() < 0) {
                    // 库存减少
                    reduceStockSkuList.add(sku);
                }
                updateSkus.add(sku);
                skuIds.add(sku.getSkuId());
            } else if (Objects.isNull(sku.getSkuId())){
                insertSkus.add(sku);
            }
        }
        // 新增的sku--保存
        if(CollUtil.isNotEmpty(insertSkus)) {
            save(spuId,insertSkus, AuthUserContext.get().getSysType(), AuthUserContext.get().getUserId(), AuthUserContext.get().getTenantId());
        }
        // 已有的sku--更新
        if(CollUtil.isNotEmpty(updateSkus)){
            List<Sku> skus = mapperFacade.mapAsList(updateSkus, Sku.class);
            List<SkuVO> skuDbPriceList = skuMapper.getSkuBatch(updateSkus.stream().map(SkuDTO::getSkuId).collect(Collectors.toList()));
            List<SpuPriceLog> spuPriceLogList = new ArrayList<>();
            for(SkuVO skuVO : skuDbPriceList){
                List<SkuDTO> skuGetById = updateSkus.stream().filter(item -> item.getSkuId().equals(skuVO.getSkuId())).collect(Collectors.toList());
                //供应商修改商品价格时，生成调价记录
                if(Objects.equals(AuthUserContext.get().getSysType(), SysTypeEnum.SUPPLIER.value()) && CollUtil.isNotEmpty(skuGetById) && !Objects.equals(skuGetById.get(0).getPriceFee(), skuVO.getPriceFee())){
                    SpuPriceLog spuPriceLog = new SpuPriceLog();
                    spuPriceLog.setSpuId(skuVO.getSpuId());
                    spuPriceLog.setSkuId(skuVO.getSkuId());
                    spuPriceLog.setBeforePrice(skuVO.getPriceFee());
                    spuPriceLog.setAfterPrice(skuGetById.get(0).getPriceFee());
                    spuPriceLog.setPrice((long) Arith.sub(spuPriceLog.getAfterPrice(), spuPriceLog.getBeforePrice()));
                    spuPriceLogList.add(spuPriceLog);
                }
            }
            skuMapper.updateBatch(skus);
            skuStockService.updateBatch(updateSkus);
            if(CollUtil.isNotEmpty(spuPriceLogList)){
                spuPriceLogMapper.insertBatch(spuPriceLogList);
            }

        }
        // 不存在的sku--删除
        skuIdsDb.removeAll(skuIds);
        if (CollUtil.isNotEmpty(skuIdsDb)) {
            deleteSkuBatch(skuIdsDb);
        }
        //商家端  生成库存出入库记录
        if(Objects.equals(AuthUserContext.get().getSysType(), SysTypeEnum.MULTISHOP.value())){
            stockBillLogChange(spuId, insertSkus, addStockSkuList, reduceStockSkuList);
        }
    }

    private void stockBillLogChange(Long spuId, List<SkuDTO> insertSkus, List<SkuDTO> addStockSkuList, List<SkuDTO> reduceStockSkuList) {
        // 记录新增的sku库存初始化
        if (CollUtil.isNotEmpty(insertSkus)) {
            //获取入库单号
            ServerResponseEntity<Long> inStockResponse = segmentFeignClient.getSegmentId(DistributedIdKey.MALL4CLOUD_PRODUCT_STOCK_IN);
            if (!inStockResponse.isSuccess()) {
                throw new LuckException(inStockResponse.getMsg());
            }
            List<StockBillLogItemVO> stockBillLogItemVOList = loadStockBillLogItems(spuId, insertSkus);
            StockBillLogVO stockBillLogVO = loadStockBillLog(StockType.WAREHOUSING.value(),StockBillType.INITIALIZE.value(), stockBillLogItemVOList,
                    AuthUserContext.get().getUserId(), AuthUserContext.get().getTenantId());
            //发送事件进行添加商品库存初始化记录
            SendStatus sendStockStatus = stockBillLogTemplate.syncSend(RocketMqConstant.STOCK_BILL_LOG_TOPIC, new GenericMessage<>(stockBillLogVO)).getSendStatus();
            if (!Objects.equals(sendStockStatus,SendStatus.SEND_OK)) {
                throw new LuckException(ResponseEnum.EXCEPTION);
            }
        }
        // 记录库存编辑增加记录
        if (CollUtil.isNotEmpty(addStockSkuList)) {
            List<StockBillLogItemVO> stockBillLogItemVOList = loadStockBillLogItems(spuId, addStockSkuList);
            StockBillLogVO stockBillLogVO = loadStockBillLog(StockType.WAREHOUSING.value(), StockBillType.EDIT_STORAGE.value(), stockBillLogItemVOList,
                    AuthUserContext.get().getUserId(), AuthUserContext.get().getTenantId());
            //发送事件进行添加商品库存初始化记录
            SendStatus sendStockStatus = stockBillLogTemplate.syncSend(RocketMqConstant.STOCK_BILL_LOG_TOPIC, new GenericMessage<>(stockBillLogVO)).getSendStatus();
            if (!Objects.equals(sendStockStatus,SendStatus.SEND_OK)) {
                throw new LuckException(ResponseEnum.EXCEPTION);
            }
        }
        // 记录库存编辑减少记录
        if (CollUtil.isNotEmpty(reduceStockSkuList)) {
            List<StockBillLogItemVO> stockBillLogItemVOList = loadStockBillLogItems(spuId, reduceStockSkuList);
            StockBillLogVO stockBillLogVO = loadStockBillLog(StockType.OUT_OF_STOCK.value(), StockBillType.EDIT_OUTBOUND.value(), stockBillLogItemVOList,
                    AuthUserContext.get().getUserId(),AuthUserContext.get().getTenantId());
            //发送事件进行添加商品库存初始化记录
            SendStatus sendStockStatus = stockBillLogTemplate.syncSend(RocketMqConstant.STOCK_BILL_LOG_TOPIC, new GenericMessage<>(stockBillLogVO)).getSendStatus();
            if (!Objects.equals(sendStockStatus,SendStatus.SEND_OK)) {
                throw new LuckException(ResponseEnum.EXCEPTION);
            }
        }
    }

    private StockBillLogVO loadStockBillLog(Integer type, Integer stockBillType, List<StockBillLogItemVO> stockBillLogItems, Long userId, Long shopId) {
        //获取入库单号
        ServerResponseEntity<Long> inStockResponse = Objects.equals(type, StockType.WAREHOUSING.value()) ? segmentFeignClient.getSegmentId(DistributedIdKey.MALL4CLOUD_PRODUCT_STOCK_IN) : segmentFeignClient.getSegmentId(DistributedIdKey.MALL4CLOUD_PRODUCT_STOCK_OUT);
        if (!inStockResponse.isSuccess()) {
            throw new LuckException(inStockResponse.getMsg());
        }
        ServerResponseEntity<ShopUserVO> userResponse = shopUserFeignClient.getByUserId(userId);
        if (!userResponse.isSuccess() || userResponse.getData() == null) {
            throw new LuckException("无法获取制单人手机号");
        }
        StockBillLogVO stockBillLog = new StockBillLogVO();
        stockBillLog.setType(type);
        stockBillLog.setStockBillNo(inStockResponse.getData().toString());
        stockBillLog.setMakerMobile(userResponse.getData().getPhoneNum());
        stockBillLog.setStockBillType(stockBillType);
        stockBillLog.setShopId(shopId);
        stockBillLog.setEmployeeId(userId);
        stockBillLog.setStatus(StockBillStatus.SUCCESS.value());
        stockBillLog.setStockBillNo(inStockResponse.getData().toString());
        stockBillLog.setBusinessTime(new Date());
        long totalAmount = 0L;
        int totalCount = 0;
        for (StockBillLogItemVO stockBillLogItem : stockBillLogItems) {
            totalAmount = totalAmount + stockBillLogItem.getUnitPrice() * stockBillLogItem.getStockCount();
            totalCount += stockBillLogItem.getStockCount();
        }
        stockBillLog.setTotalAmount(totalAmount);
        stockBillLog.setTotalCount(totalCount);
        stockBillLog.setStockBillLogItems(stockBillLogItems);
        stockBillLog.setStockBillLogItems(stockBillLogItems);
        return stockBillLog;
    }

    private List<StockBillLogItemVO> loadStockBillLogItems(Long spuId, List<SkuDTO> insertSkus) {
        List<StockBillLogItemVO> stockBillLogItems = new ArrayList<>();
        stockBillLogItems = insertSkus.stream().map(skuDTO -> {
            StockBillLogItemVO stockBillLogItemVO = new StockBillLogItemVO();
            stockBillLogItemVO.setSpuId(spuId);
            stockBillLogItemVO.setSkuId(skuDTO.getSkuId());
            stockBillLogItemVO.setStockCount(Objects.isNull(skuDTO.getChangeStock()) ? 0 :Math.abs(skuDTO.getChangeStock()));
            stockBillLogItemVO.setUnitPrice(skuDTO.getMarketPriceFee());
            return stockBillLogItemVO;
        }).collect(Collectors.toList());
        return stockBillLogItems;
    }

    @Override
    public void deleteById(Long skuId) {
        skuMapper.deleteById(skuId);
    }

    @Override
    @Cacheable(cacheNames = CacheNames.SKU_WITH_ATTR_LIST_KEY, key = "#spuId",sync = true)
    public List<SkuVO> listSkuWithAttrBySpuId(Long spuId) {
        List<SkuVO> skuList = skuMapper.listSkuWithAttrBySpuId(spuId);
        for (SkuVO skuVO : skuList) {
            if (StrUtil.isNotBlank(skuVO.getImgUrl())) {
                skuVO.setMainImgUrl(skuVO.getImgUrl());
            }
        }
        return skuList;
    }

    @Override
    public void deleteBySpuId(Long spuId) {
        if(Objects.equals(AuthUserContext.get().getSysType(), SysTypeEnum.MULTISHOP.value())) {
            //生成编辑出库记录s
            List<SkuVO> skuVOList = skuMapper.getBySpuId(spuId);
            List<SkuStockVO> skuStockVOList = skuStockMapper.listStockBySpuId(spuId);
            Map<Long, Integer> skuStockMap = skuStockVOList.stream().collect(Collectors.toMap(SkuStockVO::getSkuId, SkuStockVO::getStock));
            List<SkuDTO> reduceStockSkuList = skuVOList.stream().map(skuVO -> {
                SkuDTO skuDTO = new SkuDTO();
                skuDTO.setSkuId(skuVO.getSkuId());
                skuDTO.setPriceFee(skuVO.getPriceFee());
                skuDTO.setChangeStock(skuStockMap.get(skuVO.getSkuId()));
                skuDTO.setMarketPriceFee(skuVO.getMarketPriceFee());
                skuDTO.setSpuId(skuVO.getSpuId());
                skuDTO.setPartyCode(skuVO.getPartyCode());
                return skuDTO;
            }).collect(Collectors.toList());

            // 记录库存编辑减少记录
            if (CollUtil.isNotEmpty(reduceStockSkuList)) {
                List<StockBillLogItemVO> stockBillLogItemVOList = loadStockBillLogItems(spuId, reduceStockSkuList);
                StockBillLogVO stockBillLogVO = loadStockBillLog(StockType.OUT_OF_STOCK.value(), StockBillType.EDIT_OUTBOUND.value(), stockBillLogItemVOList,
                        AuthUserContext.get().getUserId(), AuthUserContext.get().getTenantId());
                //发送事件进行添加商品库存初始化记录
                SendStatus sendStockStatus = stockBillLogTemplate.syncSend(RocketMqConstant.STOCK_BILL_LOG_TOPIC, new GenericMessage<>(stockBillLogVO)).getSendStatus();
                if (!Objects.equals(sendStockStatus, SendStatus.SEND_OK)) {
                    throw new LuckException(ResponseEnum.EXCEPTION);
                }
            }
        }
        skuMapper.updateBySpuId(spuId);
    }

    @Override
    @Cacheable(cacheNames = CacheNames.SKU_KEY, key = "#skuId")
    public SkuVO getSkuBySkuId(Long skuId) {
        return skuMapper.getSkuBySkuId(skuId);
    }

    @Override
    public List<SkuVO> getSkuBySkuIds(List<Long> skuIds) {
        return skuMapper.getSkuBySkuIds(skuIds);
    }

    @Override
    public void updateAmountOrStock(SpuDTO spuDTO) {
        List<SkuDTO> skuList = spuDTO.getSkuList();
        List<SkuVO> skuDbList = skuMapper.getBySpuId(spuDTO.getSpuId());
        List<Sku> skus = new ArrayList<>();
        boolean isUpdateStock = false;
        List<SpuPriceLog> spuPriceLogList = new ArrayList<>();
        List<SkuDTO> addStockSkuList = new ArrayList<>();
        List<SkuDTO> reduceStockSkuList = new ArrayList<>();
        for (SkuDTO skuDTO : skuList) {
            if (Objects.nonNull(skuDTO.getChangeStock()) && !Objects.equals(skuDTO.getChangeStock(), 0)) {
                isUpdateStock = true;
                SkuVO skuDb = skuDbList.stream().filter(sku->Objects.equals(skuDTO.getSkuId(), sku.getSkuId())).findFirst().get();
                skuDTO.setMarketPriceFee(skuDb.getMarketPriceFee());
                skuDTO.setPriceFee(skuDb.getPriceFee());
                if(Objects.nonNull(skuDTO.getChangeStock()) &&skuDTO.getChangeStock() > 0){
                    addStockSkuList.add(skuDTO);
                }else {
                    reduceStockSkuList.add(skuDTO);
                }
                break;
            } else if (Objects.nonNull(skuDTO.getPriceFee())) {
                //供应商修改商品价格，生成对应的调价记录
                List<SkuVO> skuDb = skuDbList.stream().filter(item -> item.getSkuId().equals(skuDTO.getSkuId())).collect(Collectors.toList());
                if(Objects.equals(AuthUserContext.get().getSysType(), SysTypeEnum.SUPPLIER.value()) && CollUtil.isNotEmpty(skuDb) && (!skuDb.get(0).getPriceFee().equals(skuDTO.getPriceFee()))){
                    SpuPriceLog spuPriceLog = new SpuPriceLog();
                    spuPriceLog.setSpuId(spuDTO.getSpuId());
                    spuPriceLog.setSkuId(skuDTO.getSkuId());
                    spuPriceLog.setBeforePrice(skuDb.get(0).getPriceFee());
                    spuPriceLog.setAfterPrice(skuDTO.getPriceFee());
                    spuPriceLog.setPrice((long) Arith.sub(spuPriceLog.getAfterPrice(), spuPriceLog.getBeforePrice()));
                    spuPriceLogList.add(spuPriceLog);
                }
                Sku sku = new Sku();
                sku.setSkuId(skuDTO.getSkuId());
                sku.setPriceFee(skuDTO.getPriceFee());
                skus.add(sku);
            }
        }
        if (isUpdateStock) {
            skuStockService.updateBatch(skuList);
            //商家端生成库存出入库记录
            if(Objects.equals(SysTypeEnum.MULTISHOP.value(), AuthUserContext.get().getSysType())){
                stockBillLogChange(spuDTO.getSpuId(),  null, addStockSkuList, reduceStockSkuList);
            }
        }
        if (CollUtil.isNotEmpty(skus)) {
            skuMapper.updateBatch(skus);
        }
        if(!Objects.equals(spuDTO.getSupplierId(), -1L) && (isUpdateStock || CollUtil.isNotEmpty(skus))){
            SpuSupplierChangeLog spuSupplierChangeLog = new SpuSupplierChangeLog();
            spuSupplierChangeLog.setSpuId(spuDTO.getSpuId());
            spuSupplierChangeLog.setChangeType(3);
            spuSupplierChangeLogService.save(spuSupplierChangeLog);
        }
        if(CollUtil.isNotEmpty(spuPriceLogList)){
            spuPriceLogMapper.insertBatch(spuPriceLogList);
        }

    }

    @Override
    public List<SkuAppVO> getSpuDetailSkuInfo(SpuVO spu) {
        // 从缓存获取sku的数据
        List<SkuVO> skuData = new ArrayList<>();
        if (Objects.nonNull(spu.getSupplierSpuType()) && Objects.equals(spu.getSupplierDeliveryType(),SupplierDeliveryType.SUPPLIER_DELIVERY.value())){
            skuData = listConsignmentSku(spu, true);
        }else {
            skuData = listSkuAllInfoBySpuId(spu.getSpuId(), true);
        }
        List<SkuAppVO> skuAppList = new ArrayList<>();
        for (SkuVO sku : skuData) {
            SkuAppVO skuAppVO = mapperFacade.map(sku, SkuAppVO.class);
            if (Objects.nonNull(sku.getSupplierStock())) {
                skuAppVO.setStock(sku.getSupplierStock());
            }
            skuAppVO.setProperties(spliceProperties(sku.getSpuSkuAttrValues()));
            skuAppList.add(skuAppVO);
        }

        return skuAppList;
    }

    @Override
    public List<SkuVO> listBySpuIds(List<Long> spuIds){
        List<SkuVO> skuList = new ArrayList<>();
        for (Long spuId : spuIds) {
            // 从缓存获取sku的数据
            SkuServiceImpl skuService = (SkuServiceImpl) AopContext.currentProxy();

            // 从缓存获取sku的数据
            List<SkuVO> skus = skuService.listSkuWithAttrBySpuId(spuId);
            // 启用的sku，app查询到的商品是启用sku的商品
            skus = skus.stream().filter(skuVO -> Objects.equals(skuVO.getStatus(), 1)).collect(Collectors.toList());
            // 因为库存的缓存是经常变的，而规格信息的缓存是几乎不变的，所以库存的缓存要独立拿出来
            List<SkuStockVO> skuStocks = skuStockService.listStockBySpuId(spuId);

            for (SkuVO skuVO : skus) {
                for (SkuStockVO skuStock : skuStocks) {
                    if (Objects.equals(skuStock.getSkuId(), skuVO.getSkuId())) {
                        skuVO.setStock(skuStock.getStock());
                    }
                }
            }
            ProductLangUtil.skuList(skus);
            skuList.addAll(skus);
        }
        return skuList;
    }

    @Override
    public List<SkuVO> listSupplierBySpuIds(List<Long> spuIds, Long shopId) {
        List<SkuVO> skuList = new ArrayList<>();
        for (Long spuId : spuIds) {
            // 从缓存获取sku的数据
            SkuServiceImpl skuService = (SkuServiceImpl) AopContext.currentProxy();
            List<SkuVO> skus = skuService.listSkuWithAttrBySpuId(spuId);
            // 启用的sku，app查询到的商品是启用sku的商品
            skus = skus.stream().filter(skuVO -> Objects.equals(skuVO.getStatus(), 1)).collect(Collectors.toList());
            // 查找供应商商品库存（因为库存的缓存是经常变的，而规格信息的缓存是几乎不变的，所以库存的缓存要独立拿出来）
            List<SkuStockVO> skuStocks = skuStockService.listStockBySpuId(spuId);
            Map<Long, Integer> supplierSkuStockMap = null;
            if (skuStocks != null) {
                supplierSkuStockMap = skuStocks.stream().collect(Collectors.toMap(SkuStockVO::getSkuId, SkuStockVO::getStock));
            }
            // 查找商家对应该商品的库存
            List<SkuStockVO> shopSkuStocks;
            Map<Long, Integer> shopSkuStockMap = null;
            if (shopId != null) {
                shopSkuStocks = skuStockService.listShopStockBySpuIdAndShopId(spuId, shopId);
                if (shopSkuStocks != null) {
                    shopSkuStockMap = shopSkuStocks.stream().collect(Collectors.toMap(SkuStockVO::getSkuId, SkuStockVO::getStock));
                }
            }
            // 补充上库存信息(供应商&商家)
            for (SkuVO skuVO : skus) {
                if (supplierSkuStockMap != null) {
                    skuVO.setSupplierStock(supplierSkuStockMap.getOrDefault(skuVO.getSkuId(), 0));
                }
                if (shopSkuStockMap != null) {
                    skuVO.setStock(shopSkuStockMap.getOrDefault(skuVO.getSkuId(), 0));
                }
            }
            ProductLangUtil.skuList(skus);
            skuList.addAll(skus);
        }
        return skuList;
    }


    @Override
    public String spliceProperties(List<SpuSkuAttrValueVO> spuSkuAttrValueList) {
        StringBuilder properties = new StringBuilder();
        for (SpuSkuAttrValueVO spuSkuAttrValue : spuSkuAttrValueList) {
            if (CollUtil.isEmpty(spuSkuAttrValue.getSpuSkuAttrValueLangList())) {
                continue;
            }
            properties.append(spuSkuAttrValue.getAttrName()).append(Constant.COLON).append(spuSkuAttrValue.getAttrValueName()).append(Constant.SEMICOLON);
        }
        if (StrUtil.isBlank(properties.toString())) {
            return properties.toString();
        }
        return properties.substring(0, properties.length()-1);
    }


    private void deleteSkuBatch(List<Long> skuIds) {
        List<Sku> skus = new ArrayList<>();
        for (Long skuId : skuIds) {
            Sku sku = new Sku();
            sku.setSkuId(skuId);
            sku.setStatus(StatusEnum.DELETE.value());
            skus.add(sku);
        }
        skuMapper.updateBatch(skus);
        spuSkuAttrValueService.changeStatusBySkuId(skuIds, StatusEnum.DELETE.value());
    }


    @Override
    public List<SkuVO> listSkuAllInfoBySpuId(Long spuId, boolean enable) {
        SkuServiceImpl skuService = (SkuServiceImpl) AopContext.currentProxy();

        // 从缓存获取sku的数据
        List<SkuVO> skus = skuService.listSkuWithAttrBySpuId(spuId);

        if (enable) {
            // 启用的sku，app查询到的商品是启用sku的商品
            skus = skus.stream().filter(skuVO -> Objects.equals(skuVO.getStatus(), 1)).collect(Collectors.toList());
        }

        // 因为库存的缓存是经常变的，而规格信息的缓存是几乎不变的，所以库存的缓存要独立拿出来
        List<SkuStockVO> skuStocks = skuStockService.listStockBySpuId(spuId);

        for (SkuVO skuVO : skus) {
            for (SkuStockVO skuStock : skuStocks) {
                if (Objects.equals(skuStock.getSkuId(), skuVO.getSkuId())) {
                    skuVO.setStock(skuStock.getStock());
                }
            }
        }
        ProductLangUtil.skuList(skus);
        return skus;
    }

    @Override
    public List<SpuExcelVO> excelSkuList(List<Long> spuIds) {
        if (CollUtil.isEmpty(spuIds)) {
            return new ArrayList<>();
        }
        List<SpuExcelVO> spuExcelList = new ArrayList<>();
        List<SkuVO> skuList = skuMapper.excelSkuList(spuIds);
        for (SkuVO skuVO : skuList) {
            SpuExcelVO spuExcelVO = mapperFacade.map(skuVO, SpuExcelVO.class);
            spuExcelVO.setPriceFee(skuVO.getPriceFee().toString());
            spuExcelVO.setMarketPriceFee(skuVO.getMarketPriceFee().toString());
            spuExcelVO.setImgs(skuVO.getImgUrl());
            for (SkuLangVO skuLangVO : skuVO.getSkuLangList()) {
                if (Objects.equals(skuLangVO.getLang(), LanguageEnum.LANGUAGE_ZH_CN.getLang())) {
                    ProductLangUtil.spuSkuAttrValueList(skuVO.getSpuSkuAttrValues(), skuLangVO.getLang());
                    spuExcelVO.setPropertiesZh(spliceProperties(skuVO.getSpuSkuAttrValues()));
                    spuExcelVO.setSkuNameZh(skuLangVO.getSkuName());
                } else if (Objects.equals(skuLangVO.getLang(), LanguageEnum.LANGUAGE_EN.getLang())) {
                    ProductLangUtil.spuSkuAttrValueList(skuVO.getSpuSkuAttrValues(), skuLangVO.getLang());
//                    spuExcelVO.setPropertiesEn(spliceProperties(skuVO.getSpuSkuAttrValues()));
//                    spuExcelVO.setSkuNameEn(skuLangVO.getSkuName());
                }
            }
            spuExcelList.add(spuExcelVO);
        }
        return spuExcelList;
    }

    @Override
    public List<SkuVO> listSkuPriceByIds(List<Long> skuIds) {
        if (CollUtil.isEmpty(skuIds)) {
            return new ArrayList<>();
        }
        return skuMapper.listSkuPriceByIds(skuIds);
    }

    @Override
    public List<SkuAddrVO> listSpuDetailByIds(List<Long> skuIds) {
        return skuMapper.listSpuDetailByIds(skuIds);
    }

    @Override
    public Long getMinPriceFeeByIds(List<Long> skuIds) {
        return skuMapper.getMinPriceFeeByIds(skuIds);
    }

    @Override
    public List<SupplierSpuExcelVO> excelSupplierSkuList(List<Long> spuIds) {
        if (CollUtil.isEmpty(spuIds)) {
            return new ArrayList<>();
        }
        List<SupplierSpuExcelVO> spuExcelList = new ArrayList<>();
        List<SkuVO> skuList = skuMapper.excelSkuList(spuIds);
        List<Long> supplierSkuIds = skuList.stream().map(e -> e.getSupplierSkuId()).collect(Collectors.toList());
        //根据供应商品sku获取供货价
        List<SkuVO> skuVoList = skuMapper.listSkuPriceByIds(supplierSkuIds);
        Map<Long, Long> collect = skuVoList.stream().collect(Collectors.toMap(SkuVO::getSkuId, SkuVO::getPriceFee));
        for (SkuVO skuVO : skuList) {
            SupplierSpuExcelVO spuExcelVO = mapperFacade.map(skuVO, SupplierSpuExcelVO.class);
            spuExcelVO.setPriceFee(skuVO.getPriceFee().toString());
            spuExcelVO.setMarketPriceFee(skuVO.getMarketPriceFee().toString());
            //设置供货价
            String supplierPrice = collect.get(skuVO.getSupplierSkuId()).toString();
            if (!Objects.isNull(supplierPrice)){
                spuExcelVO.setSupplyPrice(supplierPrice);
            }
            for (SkuLangVO skuLangVO : skuVO.getSkuLangList()) {
                if (Objects.equals(skuLangVO.getLang(), LanguageEnum.LANGUAGE_ZH_CN.getLang())) {
                    ProductLangUtil.spuSkuAttrValueList(skuVO.getSpuSkuAttrValues(), skuLangVO.getLang());
                    spuExcelVO.setPropertiesZh(spliceProperties(skuVO.getSpuSkuAttrValues()));
                    spuExcelVO.setSkuNameZh(skuLangVO.getSkuName());
                }
            }
            spuExcelList.add(spuExcelVO);
        }
        return spuExcelList;
    }

    @Override
    public List<SkuVO> listByPartyCodeList(List<String> partyCodeList) {
        return skuMapper.listByPartyCodeList(partyCodeList);
    }

    @Override
    public List<SkuVO> listConsignmentSku(SpuVO spu, boolean enable) {
        SkuServiceImpl skuService = (SkuServiceImpl) AopContext.currentProxy();
        //获取供应商品sku
        List<SkuVO> supplierSkuList = skuService.listSkuWithAttrBySpuId(spu.getSupplierSpuId());
        Map<Long, SkuVO> skuMap = supplierSkuList.stream().collect(Collectors.toMap(SkuVO::getSkuId, s -> s));
        //代销商品SKU
        List<SkuVO> skuVoList = skuService.listSkuWithAttrBySpuId(spu.getSpuId());
        // 因为库存的缓存是经常变的，而规格信息的缓存是几乎不变的，所以库存的缓存要独立拿出来
        //供应商SKU库存
        List<SkuStockVO> supplierSkuStocks = skuStockService.listStockBySpuId(spu.getSupplierSpuId());
        //商家自己库存
        List<SkuStockVO> skuStocks = skuStockService.listStockBySpuId(spu.getSpuId());
        Map<Long, Integer> supplierSkuStock = supplierSkuStocks.stream().collect(Collectors.toMap(SkuStockVO::getSkuId, SkuStockVO::getStock));
        Map<Long, Integer> skuStock = skuStocks.stream().collect(Collectors.toMap(SkuStockVO::getSkuId, SkuStockVO::getStock));
        List<SkuVO> deletedsupplierSkuVoList = new ArrayList<>();
        for (SkuVO skuVO : skuVoList) {
            skuVO.setStock(skuStock.get(skuVO.getSkuId()));

            //供应商商品信息
            SkuVO supplierSkuVO = skuMap.get(skuVO.getSupplierSkuId());
            if (Objects.isNull(supplierSkuVO)) {
                deletedsupplierSkuVoList.add(skuVO);
                continue;
            }
            if (Objects.equals(spu.getSupplierDeliveryType(), SupplierDeliveryType.SUPPLIER_DELIVERY.value())){
                logger.info("供应商发货代销商品，代销商品sku状态为供应商商品sku状态");
                skuVO.setStatus(supplierSkuVO.getStatus());
            }
            skuVO.setWeight(supplierSkuVO.getWeight());
            skuVO.setVolume(supplierSkuVO.getVolume());
            skuVO.setSupplyPriceFee(supplierSkuVO.getPriceFee());
            skuVO.setSupplierSkuCode(supplierSkuVO.getPartyCode());
            skuVO.setSupplierSkuStatus(supplierSkuVO.getStatus());
            if (supplierSkuVO.getStatus() >= 0) {
                skuVO.setIsSell(supplierSkuVO.getStatus());
            }
            skuVO.setSupplierStock(supplierSkuStock.get(skuVO.getSupplierSkuId()));
        }
        //移除供应商已删除的sku
        skuVoList.removeAll(deletedsupplierSkuVoList);
        if (enable) {
            // 启用的sku，app查询到的商品是启用sku的商品
            skuVoList = skuVoList.stream().filter(skuVO -> Objects.equals(skuVO.getSupplierSkuStatus(), 1)).collect(Collectors.toList());
        }
        ProductLangUtil.skuList(skuVoList);
        return skuVoList;
    }

    @Override
    public StockBillLogItemDTO getSkuByPartyCodeAndShopId(String partyCode, Long shopId) {
        return skuMapper.getSkuByPartyCodeAndShopId(partyCode, shopId);
    }

    @Override
    public List<String> listSkuPartyCodesByShopId(Long shopId, Integer sysType, Long spuId) {

        return skuMapper.listSkuPartyCodesByShopId(shopId,sysType,spuId);
    }


    @Override
    public List<SkuExcelVO> exportSkuList(ProductSearchDTO product) {
        List<SkuVO> skuList = skuMapper.listExportSku(product);
        List<SkuExcelVO> skuExcelList = new ArrayList<>();
        skuExcelList = skuList.stream().map(skuVO -> {
            SkuExcelVO skuExcelVO = new SkuExcelVO();
            skuExcelVO.setSkuId(skuVO.getSkuId());
            skuExcelVO.setSkuName(skuVO.getSkuName());
            skuExcelVO.setSpuName(skuVO.getSpuName());
            skuExcelVO.setPartyCode(skuVO.getPartyCode());
            skuExcelVO.setStock(skuVO.getStock());
            skuExcelVO.setPriceFee(conversionPrices(skuVO.getPriceFee().toString()));
            return skuExcelVO;
        }).collect(Collectors.toList());
        return  skuExcelList;

    }

    /**
     * 金额Long格式转换Double
     * @param num
     * @return 金额字符串
     */
    private String conversionPrices(String num) {
        if (StrUtil.isBlank(num)) {
            return num;
        }
        BigDecimal b1 = new BigDecimal(num);
        BigDecimal b2 = new BigDecimal(Constant.PRICE_MAGNIFICATION);
        double price = b1.divide(b2, 2, BigDecimal.ROUND_HALF_UP).doubleValue();
        return Double.toString(price);
    }

    @Override
    public void synCommissionSku(Long supplierSpuId) {
        //获取供应商发货的代销商品Id
        List<SpuVO> commissionSpuList = spuMapper.getCommissionSpuListBySupplierDeliver(supplierSpuId);
        List<Long> commissionSpuIdList = commissionSpuList.stream().map(e -> e.getSpuId()).collect(Collectors.toList());
        //获取供应商sku信息
        List<SkuVO> supplierSku = skuMapper.listSkuWithAttrBySpuId(supplierSpuId);
        List<Long> supplierSkuIds = supplierSku.stream().map(e -> e.getSkuId()).collect(Collectors.toList());
        for (int i = 0; i < commissionSpuList.size(); i++) {
            //获取代销商品sku信息
            List<SkuVO> skuVoList = skuMapper.listSkuWithAttrBySpuId(commissionSpuIdList.get(i));
            List<Long> commissionSupplierSkuIds = skuVoList.stream().map(e -> e.getSupplierSkuId()).collect(Collectors.toList());
            List<Long> intersectionSkuId = supplierSkuIds.stream().filter(item -> commissionSupplierSkuIds.contains(item)).collect(Collectors.toList());
            List<Long> supplierSkuIdsF = supplierSkuIds;
            supplierSkuIdsF.removeAll(intersectionSkuId);
            List<SkuVO> skuBatch = skuMapper.getSkuBatch(supplierSkuIdsF);
            List<SkuDTO> skuDtoList = new ArrayList<>();
            //获取商家代销设置
            ServerResponseEntity<ShopSubstituteSalesVO> salesType = shopSubstituteSalesFeignClient.getByShopSubstituteSalesId(commissionSpuList.get(i).getShopId());
            ShopSubstituteSalesVO shopSubstituteSalesVO = salesType.getData();
            for (SkuVO skuVO : skuBatch) {
                if (shopSubstituteSalesVO.getSalesType() == 0){
                    //智能设价计算售价
                    Long price = 0L;
                    if (Objects.equals(shopSubstituteSalesVO.getSalesPriceType(), SalesPriceType.PROPORTION_PRICE.value())){
                        //按比例加价
                        price = PriceUtil.divideByBankerRounding(skuVO.getPriceFee() * shopSubstituteSalesVO.getSalesPrice(),10000) + skuVO.getPriceFee();
                    }
                    if (Objects.equals(shopSubstituteSalesVO.getSalesPriceType(),SalesPriceType.FIXED_NUMBER_PRICE.value())){
                        //按固定数值加价
                        price = skuVO.getPriceFee() + shopSubstituteSalesVO.getSalesPrice();
                    }
                    skuVO.setPriceFee(price);
                    skuVO.setMarketPriceFee(price);
                }
                SkuDTO skuDTO = mapperFacade.map(skuVO, SkuDTO.class);
                skuDTO.setSupplierSkuId(skuDTO.getSkuId());
                skuDTO.setSpuId(null);
                skuDTO.setStock(skuVO.getStock());
                skuDtoList.add(skuDTO);
            }
            for (SkuVO skuVo : skuVoList) {
                SkuDTO map = mapperFacade.map(skuVo, SkuDTO.class);
                skuDtoList.add(map);
            }
            //保存sku信息
            save(commissionSpuIdList.get(i), skuDtoList, AuthUserContext.get().getSysType(), AuthUserContext.get().getUserId(), AuthUserContext.get().getTenantId());
        }
    }

    @Override
    public Integer getStockWarningNum(ProductSearchDTO product) {
        return skuMapper.getStockWarningNum(product);
    }

    @Override
    public void commissionSave(Long spuId, List<SkuDTO> skuList,Integer sysType) {
        skuList.forEach(sku -> {
            sku.setSpuId(spuId);
            if(Objects.isNull(sku.getStatus())){
                sku.setStatus(StatusEnum.ENABLE.value());
            }
            if (StrUtil.isBlank(sku.getImgUrl())) {
                sku.setImgUrl(null);
            }
            if (Objects.isNull(sku.getScoreFee())) {
                sku.setScoreFee(Constant.ZERO_LONG);
            }
        });
        // 处理数据，保存库存、属性
        skuMapper.saveBatch(skuList);
        List<SkuVO> skuDbList = skuMapper.getBySpuId(spuId);
        List<SkuStock> skuStocks = new ArrayList<>();
        List<SpuSkuAttrValueDTO> spuSkuAttrValues = new ArrayList<>();
        List<SkuLangDTO> skuLangList = new ArrayList<>();
        for (SkuDTO skuDTO : skuList) {
            SkuStock skuStock = new SkuStock();
            skuStock.setSkuId(skuDTO.getSkuId());
            skuStock.setStock(skuDTO.getStock());
            skuStock.setActualStock(skuDTO.getStock());
            skuStock.setLockStock(0);
            skuStock.setSpuId(spuId);
            skuStocks.add(skuStock);
            if (CollUtil.isEmpty(skuDTO.getSpuSkuAttrValues())) {
                continue;
            }
            for (SkuLangDTO skuLangDTO : skuDTO.getSkuLangList()) {
                skuLangDTO.setSkuId(skuDTO.getSkuId());
                skuLangList.add(skuLangDTO);
            }
            for (SpuSkuAttrValueDTO spuSkuAttrValue : skuDTO.getSpuSkuAttrValues()) {
                spuSkuAttrValue.setSpuId(spuId);
                spuSkuAttrValue.setSkuId(skuDTO.getSkuId());
                spuSkuAttrValue.setStatus(StatusEnum.ENABLE.value());
                spuSkuAttrValues.add(spuSkuAttrValue);
            }
        }
        skuLangService.batchSave(mapperFacade.mapAsList(skuLangList, SkuLang.class));
        skuStockService.batchSave(skuStocks);
        spuSkuAttrValueService.commissionSave(spuSkuAttrValues,sysType);
        //供应商新增sku时，生成对应的变更记录
        if(skuList.size() > skuDbList.size()){
            SpuSupplierChangeLog spuSupplierChangeLog = new SpuSupplierChangeLog();
            spuSupplierChangeLog.setSpuId(spuId);
            spuSupplierChangeLog.setChangeType(SupplierSpuChangeType.ADD_SKU.value());
            spuSupplierChangeLogService.save(spuSupplierChangeLog);
        }

    }

    @Override
    public Map<Long,Integer> getSupplierSkuStock(Long spuId,Long supplierSpuId){
        List<SkuVO> skuList = skuMapper.listSkuWithAttrBySpuId(spuId);
        //供应商SKU库存
        List<SkuStockVO> supplierSkuStocks = skuStockService.listStockBySpuId(supplierSpuId);
        Map<Long, Integer> supplierSkuStock = supplierSkuStocks.stream().collect(Collectors.toMap(SkuStockVO::getSkuId, SkuStockVO::getStock));
        for (SkuVO skuVO : skuList) {
            skuVO.setSupplierStock(supplierSkuStock.get(skuVO.getSupplierSkuId()));
        }
        Map<Long, Integer> skuStock = skuList.stream().collect(Collectors.toMap(SkuVO::getSkuId, SkuVO::getSupplierStock));
        return skuStock;
    }

    @Override
    public int updateSkuStock(Long skuId, Integer changeCount, Long spuId) {
        RLock lock = redissonClient.getLock(LockCacheNames.LOCK_ZONE_PREFIX + skuId);
        try {
            lock.lock();
            SkuZoneInfoBO zoneInfo = skuStockService.getZoneInfo(skuId);
            // 如果获取到sku的分片缓存为null，就刷新下
            if (Objects.isNull(zoneInfo)) {
                RedisUtil.del(ProductCacheNames.SKU_ZONE_INFO + CacheNames.UNION + skuId);
                zoneInfo = skuStockService.getZoneInfo(skuId);
            }
            if (!BooleanUtil.isTrue(zoneInfo.getHasZone())) {
                // 未分片用老方法更新库存
                return skuStockMapper.updateSkuStock(skuId, changeCount);
            }
            // 分片过
            return skuStockService.changeSkuWhenZone(skuId, changeCount, spuId);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public List<SkuVO> getByIds(List<Long> skuIds) {
        return skuMapper.getSkuBatch(skuIds);
    }

    @Override
    public List<SpuAdminVO> setSpuSku(List<SpuAdminVO> spuAdminList) {
        List<Long> spuIdList = spuAdminList.stream().map(e -> e.getSpuId()).collect(Collectors.toList());
        if (spuIdList.size() == 0){
            return spuAdminList;
        }
        List<SkuVO> skuList = skuMapper.getSkuList(spuIdList);
        Map<Long, List<SkuVO>> skuVoBySpuId = skuList.stream().collect(Collectors.groupingBy(SkuVO::getSpuId));
        List<Long> supplierSpuId = new ArrayList<>();
        for (SpuAdminVO spuAdminVO : spuAdminList) {
            List<SkuVO> skuVoList = skuVoBySpuId.get(spuAdminVO.getSpuId());
            if (Objects.equals(spuAdminVO.getSupplierDeliveryType(), SupplierDeliveryType.SUPPLIER_DELIVERY.value())){
                logger.info("供应商自发货商品");
                List<Long> supplierSkuIdList = skuVoList.stream().map(SkuVO::getSupplierSkuId).collect(Collectors.toList());
                List<SkuVO> supplierSkuList = skuMapper.getSkuBatch(supplierSkuIdList);
                Map<Long, Integer> supplierSkuStatusMap = supplierSkuList.stream().collect(Collectors.toMap(SkuVO::getSkuId, SkuVO::getStatus));
                Iterator<SkuVO> iterator = skuVoList.iterator();
                while (iterator.hasNext()){
                    SkuVO skuVO = iterator.next();
                    if (Objects.equals(supplierSkuStatusMap.get(skuVO.getSupplierSkuId()), StatusEnum.DISABLE.value())){
                        logger.info("供应商自发货商品，过滤掉不是正常状态的sku，skuId:{}", skuVO.getSkuId());
                        iterator.remove();
                    }
                }
            }
            // 获取库存信息
            List<SkuStockVO> skuStockList = skuStockService.listStockBySpuId(spuAdminVO.getSpuId());
            setSkuInfo(skuVoList, skuStockList);
            //sku名称国际化
            spuAdminVO.setSkuList(skuVoList);
            if (Objects.equals(spuAdminVO.getSupplierSpuType(),SupplierSpuType.CONSIGNMENT.value())){
                supplierSpuId.add(spuAdminVO.getSupplierSpuId());
                //供应商SKU库存
                List<SkuStockVO> supplierSkuStocks = skuStockService.listStockBySpuId(spuAdminVO.getSupplierSpuId());
                Map<Long, Integer> supplierSkuStock = supplierSkuStocks.stream().collect(Collectors.toMap(SkuStockVO::getSkuId, SkuStockVO::getStock));
                for (SkuVO skuVO : spuAdminVO.getSkuList()) {
                    skuVO.setStock(supplierSkuStock.get(skuVO.getSupplierSkuId()));
                }
            }
        }
        return spuAdminList;
    }
    private void setSkuInfo(List<SkuVO> skuVOList, List<SkuStockVO> skuStockList) {
        Map<Long, Integer> stockMap = skuStockList.stream().collect(Collectors.toMap(SkuStockVO::getSkuId, SkuStockVO::getStock));
        for (SkuVO skuVO : skuVOList) {
            if (stockMap.containsKey(skuVO.getSkuId())) {
                skuVO.setStock(stockMap.get(skuVO.getSkuId()));
            }
            List<SkuLangVO> skuLangList = skuVO.getSkuLangList();
            if (skuLangList.size() == 0){
                break;
            }
            Iterator<SkuLangVO> iterator = skuLangList.iterator();
            while (iterator.hasNext()){
                SkuLangVO skuLangVO = iterator.next();
                if (Objects.isNull(skuLangVO.getLang()) || Objects.isNull(skuLangVO.getSkuName())){
                    iterator.remove();
                }
            }
            Map<Integer, String> stringMap = skuLangList.stream().collect(Collectors.toMap(SkuLangVO::getLang, SkuLangVO::getSkuName));
            skuVO.setSkuName(stringMap.get(I18nMessage.getLang()));
        }

    }

    @Override
    public PageVO<SkuVO> pageSku(PageDTO pageDTO, ProductSearchDTO product) {
        return PageUtil.doPage(pageDTO, () -> skuMapper.pageSku(product));
    }

    @Override
    public List<SkuDTO> listSkuDtoBySkuIds(List<Long> skuIds) {
        if (CollectionUtils.isEmpty(skuIds)) {
            return new ArrayList<>();
        }
        return skuMapper.listSkuDTOBySkuIds(skuIds);
    }


}
